…plain lossless

Replace every --delta-full-interval 10000 occurrence with 30 (the actual
argparse default) and add an inline note at each site: setting the flag to a
very large integer (e.g. 10000) effectively disables periodic full syncs,
which is fine because with --delta-dtype fp32 the apply is lossless — every
bf16 value is exactly representable in fp32, the subtraction captures the
exact difference between two stored bf16 values, and the receiver's in-place
bf16 += fp32 add reproduces the trainer's bf16 state bit-for-bit on rounding
back, so no error accumulates across deltas.

Updates: example script, example README, en + zh docs.

…artial*

Add a second partial-update mode 'selective' alongside the existing 'delta'.
Both share the snapshot, sparse encoding, periodic-base-sync, and bucketed
broadcast machinery; they differ in what's on the wire and how the receiver
applies it:

  delta     — wire = (current − snapshot) at delta_dtype;
              receiver: param += delta (in-place add, auto-promotes for fp32
              math, casts back to param dtype on store).
  selective — wire = new param values at changed positions, with NaN as the
              "unchanged" sentinel in the dense decoded tensor;
              receiver: param[~isnan(src)] = src[~isnan(src)] (selective
              overwrite, leaves NaN positions untouched).

Selective is lossless by construction (no arithmetic), the wire values portion
is ~½ the size of fp32 delta, and the per-element apply is a direct masked
copy. Selective requires float param dtype on the wire (validated at decode);
slime always sends HF-format floats so this holds in practice.

CLI rename: every flag now lives under --update-weight-*. Scope is encoded in
the name itself:
  --update-weight-mode {full, delta, selective}
  --update-weight-delta-dtype                  # delta-only
  --update-weight-partial-encoding             # delta + selective
  --update-weight-base-sync-interval           # delta + selective
  --update-weight-partial-artifact-dir         # delta + selective
  --sglang-update-weight-partial-chunk-bytes   # delta + selective (receiver)

Internal naming follows: WeightDelta* → PartialWeight* on the wire,
UpdateWeightFromDistributedDelta → UpdateWeightFromDistributedPartial,
DeltaSync → PartialSync, _decode_sparse_delta → _decode_sparse_partial,
_additive_load_context stays + new _selective_load_context (they share a
_param_storage_predicate helper + _patched_in_place_writes scaffolding).
File: update_weight_from_distributed_delta.py → ..._partial.py.

The slime orchestrator is one class (UpdateWeightFromDistributedPartial) with
mode branching in _enqueue_partial_chunk; _send_partial_weights body is
shared. The SGLang receiver dispatches on load_format ("delta" or "selective")
to one of two thin entry points that share _update_partial_weights_from_distributed.

Wire schema: single PartialWeightSpec class shared by both modes (structurally
identical wire format); request field is .partial (was .delta).

Docs (en + zh) and the example script use the new flag names and document
selective mode without perf numbers (pending experiment).

The feature now covers two peer modes (delta + selective), so 'delta
compression' is misleading at the umbrella level. Rename to 'partial weight
sync':

  docs/{en,zh}/advanced/delta-compression.md → partial-weight-sync.md
  examples/delta_compression/                 → examples/partial_weight_sync/
  examples/.../run-glm4.7-355B-A32B-delta.sh  → ..._partial.sh

Internal references and index.rst entries updated. The example script and
README now show two explicit PARTIAL_ARGS blocks (delta active by default,
selective commented out) so users can flip modes by swapping which block is
uncommented.

Adds inspiration / prior-art references (Cursor Composer 2 + Fireworks AI
for delta; arXiv:2509.19128 for selective) and a placeholder for selective
W&B traces. Also documents that this feature only changes what bytes ship
on the wire, so any future communication-layer optimization in slime stacks
additively on top.

Trainer-side observability for partial weight sync. New wandb metrics on
the rollout/step axis, emitted by UpdateWeightFromDistributedPartial:

  perf/update_weights_density       fraction of positions that moved
  perf/update_weights_is_base_sync  0/1 flag (lets you disambiguate spikes)
  perf/update_weights_wire_bytes    bytes actually shipped per sync

Plumbing: weight updaters gain an update_weight_metrics dict + pop_metrics().
The actor drains it via log_perf_data(..., extra_metrics=...), mirroring
slime's existing rollout_extra_metrics pattern in _log_rollout_data.

Other changes:
- nnz field on PartialChunk so density accounting is symmetric with byte_size
- Reorder selective before delta in all prose/tables/help text/example script
  (example script now defaults to selective; delta block commented out)
- README placeholder for the density plot under the Selective mode results
  section, with a note explaining step 0 is omitted (always base-sync = 1.0)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

…unify modes

The compute step now returns (payload, mask) per param via a new PartialPayload
dataclass; the encoder reads the mask directly instead of re-deriving it from
a sentinel. NaN no longer materialized on the sender in the common sparse
paths — only inside _encode_dense for selective (debug-only encoding).

- New PartialPayload(name, payload, mask) carrying per-param compute output.
- compute_delta + compute_selective merged into one compute_payload(mode); the
  per-mode logic lives in a closure dispatched once before the shared loop.
- _encode_sparse reads (pp.payload, pp.mask) directly; no predicate threading.
- _make_indices_kv / _make_bitmask_kv flattened to plain _indices_kv / _bitmask_kv
  (factories were vestigial once is_active capture was removed).
- Dense encoding extracted into _encode_dense; lazily NaN-marks selective tensors
  for the receiver-side sentinel — the only sender path that still touches NaN.

Net: selective saves one full-size tensor allocation per param on the sender
(no more torch.where(mask, tensor, NaN) materialization in the common case).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>